package com.chen.springboot.service;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.chen.springboot.entity.Item;
import com.chen.springboot.entity.ItemParams;
import com.chen.springboot.entity.Order;
import com.chen.springboot.entity.User;
import com.chen.springboot.mapper.ItemMapper;
import com.chen.springboot.mapper.ItemParamsMapper;
import com.chen.springboot.mapper.OrderMapper;
import com.chen.springboot.mapper.UserMapper;
import com.chen.springboot.service.OrderService;
import com.chen.springboot.utils.TokenUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.*;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * AI分析服务
 * 支持通义千问、文心一言等国内AI模型
 */
@Service
public class AiService {

    @Value("${ai.api.key:}")
    private String apiKey;

    @Value("${ai.api.url:https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation}")
    private String apiUrl;

    @Value("${ai.model:qwen-plus}")
    private String model;

    @Autowired
    private ItemMapper itemMapper;
    
    @Autowired
    private ItemParamsMapper itemParamsMapper;
    
    @Autowired
    private OrderMapper orderMapper;
    
    @Autowired
    private UserMapper userMapper;
    
    @Autowired
    private OrderService orderService;

    private RestTemplate restTemplate;

    public AiService() {
        // 配置RestTemplate的超时时间
        org.springframework.http.client.SimpleClientHttpRequestFactory factory = 
            new org.springframework.http.client.SimpleClientHttpRequestFactory();
        factory.setConnectTimeout(10000);  // 连接超时10秒
        factory.setReadTimeout(60000);     // 读取超时60秒
        this.restTemplate = new RestTemplate(factory);
        
        System.out.println("✅ AI服务初始化完成，连接超时: 10s，读取超时: 60s");
    }

    /**
     * AI助手对话
     */
    public String chatWithAI(String query) {
        // 如果没有配置API Key，使用本地分析
        if (apiKey == null || apiKey.isEmpty() || apiKey.trim().isEmpty()) {
            System.out.println("⚠️ 未配置API Key，使用本地智能分析");
            return generateLocalResponse(query);
        }

        System.out.println("🚀 开始调用通义千问API进行对话...");
        System.out.println("🔑 API Key: " + apiKey.substring(0, 10) + "..." + apiKey.substring(apiKey.length() - 4));
        System.out.println("🤖 Model: " + model);
        System.out.println("🌐 API URL: " + apiUrl);

        try {
            // 构建提示词
            String prompt = buildChatPrompt(query);
            System.out.println("📝 提示词长度: " + prompt.length() + " 字符");

            // 调用通义千问API
            String aiResponse = callQwenApi(prompt);

            System.out.println("✅ AI对话完成！结果长度: " + aiResponse.length() + " 字符");
            return aiResponse;
        } catch (Exception e) {
            System.err.println("❌ AI调用失败，错误信息: " + e.getMessage());
            e.printStackTrace();
            
            // 不再自动降级，而是抛出异常让调用方处理
            throw new RuntimeException("AI对话失败: " + e.getMessage(), e);
        }
    }

    /**
     * 商品对比分析
     */
    public String compareProducts(List<Map<String, Object>> products) {
        // 如果没有配置API Key，使用本地分析
        if (apiKey == null || apiKey.isEmpty() || apiKey.trim().isEmpty()) {
            System.out.println("⚠️ 未配置API Key，使用本地智能分析");
            return generateLocalAnalysis(products);
        }

        System.out.println("🚀 开始调用通义千问API进行分析...");
        System.out.println("🔑 API Key: " + apiKey.substring(0, 10) + "..." + apiKey.substring(apiKey.length() - 4));
        System.out.println("🤖 Model: " + model);
        System.out.println("🌐 API URL: " + apiUrl);

        try {
            // 构建提示词
            String prompt = buildComparePrompt(products);
            System.out.println("📝 提示词长度: " + prompt.length() + " 字符");

            // 调用通义千问API
            String aiResponse = callQwenApi(prompt);

            System.out.println("✅ AI分析完成！结果长度: " + aiResponse.length() + " 字符");
            return aiResponse;
        } catch (Exception e) {
            System.err.println("❌ AI调用失败，错误信息: " + e.getMessage());
            e.printStackTrace();
            
            // 不再自动降级，而是抛出异常让调用方处理
            throw new RuntimeException("AI分析失败: " + e.getMessage(), e);
        }
    }

    /**
     * 获取热门商品推荐（只推荐手办类商品）
     */
    public Map<String, Object> getHotRecommendations() {
        Map<String, Object> result = new HashMap<>();
        
        // 查询所有商品参数，筛选出手办类商品（有pvcSeries或hotSeries的商品）
        List<ItemParams> itemParamsList = itemParamsMapper.selectList(null);
        List<Long> handItemIds = itemParamsList.stream()
            .filter(params -> (params.getPvcSeries() != null && !params.getPvcSeries().trim().isEmpty()) || 
                             (params.getHotSeries() != null && !params.getHotSeries().trim().isEmpty()))
            .map(ItemParams::getItemId)
            .distinct()  // 确保ID唯一
            .collect(Collectors.toList());
        
        // 如果没有手办类商品，返回空列表
        if (handItemIds.isEmpty()) {
            result.put("items", new ArrayList<>());
            result.put("total", 0);
            return result;
        }
        
        // 根据手办商品ID查询商品信息
        List<Item> handItems = itemMapper.selectBatchIds(handItemIds);
        
        // 过滤掉无效商品（如已删除或状态异常的商品）
        List<Item> validHandItems = handItems.stream()
            .filter(item -> item != null && item.getStatus() != null && item.getStatus() == 1)
            .collect(Collectors.toList());
        
        // 按创建时间倒序排序，取前5个
        List<Item> latestItems = validHandItems.stream()
            .sorted((a, b) -> b.getCreated().compareTo(a.getCreated()))
            .limit(5)
            .collect(Collectors.toList());
        
        result.put("items", latestItems);
        result.put("total", latestItems.size());
        
        return result;
    }

    /**
     * 商品价格对比
     */
    public Map<String, Object> comparePrices(List<Map<String, Object>> products) {
        Map<String, Object> result = new HashMap<>();
        
        // 这里可以实现更复杂的价格对比逻辑
        result.put("products", products);
        
        return result;
    }

    /**
     * 获取用户订单信息
     */
    public List<Order> getUserOrders() {
        // 获取当前登录用户ID
        String userIdStr = TokenUtils.getCurrUser();
        if (userIdStr == null) {
            throw new RuntimeException("用户未登录");
        }
        
        // 查询用户订单
        return orderService.findUserOrder(1, 100, "", 0).getRecords();
    }

    /**
     * 获取用户购物车内容
     */
    public List<Order> getUserCart() {
        // 获取当前登录用户ID
        String userIdStr = TokenUtils.getCurrUser();
        if (userIdStr == null) {
            throw new RuntimeException("用户未登录");
        }
        
        // 查询用户购物车（状态为2未支付的订单）
        return orderService.findUserOrder(1, 100, "", 2).getRecords();
    }

    /**
     * 获取用户发货信息
     */
    public List<Order> getUserShippingInfo() {
        // 获取当前登录用户ID
        String userIdStr = TokenUtils.getCurrUser();
        if (userIdStr == null) {
            throw new RuntimeException("用户未登录");
        }
        
        // 查询用户已发货订单（状态为4的订单）
        return orderService.findUserOrder(1, 100, "", 4).getRecords();
    }

    /**
     * 获取用户退款信息
     */
    public List<Order> getUserRefundInfo() {
        // 获取当前登录用户ID
        String userIdStr = TokenUtils.getCurrUser();
        if (userIdStr == null) {
            throw new RuntimeException("用户未登录");
        }
        
        // 查询用户退款中订单（状态为6的订单）
        return orderService.findUserOrder(1, 100, "", 6).getRecords();
    }

    /**
     * 调用通义千问API
     */
    private String callQwenApi(String prompt) {
        try {
            System.out.println("准备API请求...");
            
            // 构建请求头
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);
            headers.set("Authorization", "Bearer " + apiKey);

            // 构建请求体
            Map<String, Object> requestBody = new HashMap<>();
            requestBody.put("model", model);
            
            Map<String, Object> input = new HashMap<>();
            
            List<Map<String, String>> messages = new ArrayList<>();
            Map<String, String> systemMessage = new HashMap<>();
            systemMessage.put("role", "system");
            systemMessage.put("content", "你是一个专业的手办购物商城助手，能够帮助用户查找手办商品、比较价格、提供购物建议。你的回答应该简洁明了，友好专业。商城的商品主要是手办类商品，包括PVC手办、动漫周边、模型等。如果用户询问具体商品信息，你可以提供相关建议，但要说明你提供的信息基于现有知识，具体购买请以实际商品为准。\n\n以下是一些商城中的手办商品信息供你参考：\n\n1. 初音未来手办：价格¥299.00，特点：高质量PVC材质，细节精致，可动人偶设计\n2. 原神手办：价格¥199.00，特点：热门游戏角色，精美造型，收藏价值高\n3. 海贼王手办：价格¥259.00，特点：经典动漫角色，动态姿势，高还原度\n4. 火影忍者手办：价格¥229.00，特点：忍者造型，武器配件齐全，适合收藏\n5. 鬼灭之刃手办：价格¥279.00，特点：动漫同款，服装细节丰富，限量版\n6. 攻壳机动队手办：价格¥349.00，特点：科幻题材，机械细节，高端收藏\n7. 龙珠手办：价格¥189.00，特点：经典角色，动作造型，性价比高\n8. 航海王模型：价格¥159.00，特点：组装模型，锻炼动手能力，适合新手\n9. 假面骑士手办：价格¥239.00，特点：特摄题材，变身形态，细节丰富");
            messages.add(systemMessage);
            
            Map<String, String> userMessage = new HashMap<>();
            userMessage.put("role", "user");
            userMessage.put("content", prompt);
            messages.add(userMessage);
            
            input.put("messages", messages);
            requestBody.put("input", input);
            
            Map<String, Object> parameters = new HashMap<>();
            parameters.put("result_format", "message");
            requestBody.put("parameters", parameters);

            HttpEntity<Map<String, Object>> entity = new HttpEntity<>(requestBody, headers);

            System.out.println("发送请求到通义千问API: " + apiUrl);
            
            // 发送请求
            ResponseEntity<String> response = restTemplate.exchange(
                apiUrl,
                HttpMethod.POST,
                entity,
                String.class
            );

            System.out.println("收到API响应，状态码: " + response.getStatusCode());

            // 解析响应
            if (response.getStatusCode() == HttpStatus.OK) {
                String responseBody = response.getBody();
                System.out.println("响应内容: " + (responseBody != null && responseBody.length() > 100 ? 
                    responseBody.substring(0, 100) + "..." : responseBody));
                
                JSONObject jsonResponse = JSON.parseObject(responseBody);
                
                // 检查是否有错误
                if (jsonResponse.containsKey("code") && !jsonResponse.getString("code").equals("Success")) {
                    String errorMsg = jsonResponse.getString("message");
                    System.err.println("API返回错误: " + errorMsg);
                    throw new RuntimeException("API错误: " + errorMsg);
                }
                
                JSONObject output = jsonResponse.getJSONObject("output");
                if (output != null && output.containsKey("choices")) {
                    JSONObject choice = output.getJSONArray("choices").getJSONObject(0);
                    JSONObject message = choice.getJSONObject("message");
                    String content = message.getString("content");
                    System.out.println("成功获取AI分析结果，长度: " + content.length() + " 字符");
                    return content;
                }
            }

            throw new RuntimeException("AI API调用失败，状态码: " + response.getStatusCode());
        } catch (Exception e) {
            System.err.println("调用通义千问API异常: " + e.getClass().getName() + " - " + e.getMessage());
            e.printStackTrace();
            throw new RuntimeException("AI API调用异常：" + e.getMessage(), e);
        }
    }

    /**
     * 构建对话提示词
     */
    private String buildChatPrompt(String query) {
        StringBuilder prompt = new StringBuilder();
        prompt.append("用户询问：").append(query).append("\n\n");
        prompt.append("请根据商城商品信息和用户问题，提供专业、友好的回答。商城的商品主要是手办类商品，包括PVC手办、动漫周边等。如果涉及具体商品推荐，请说明这是基于现有信息的建议，具体购买请以实际商品为准。\n\n");
        return prompt.toString();
    }

    /**
     * 构建对比分析提示词
     */
    private String buildComparePrompt(List<Map<String, Object>> products) {
        StringBuilder prompt = new StringBuilder();
        prompt.append("请对以下商品进行详细的对比分析，并给出购买建议：\n\n");

        for (int i = 0; i < products.size(); i++) {
            Map<String, Object> product = products.get(i);
            prompt.append("商品").append(i + 1).append("：\n");
            prompt.append("- 名称：").append(product.get("商品名称")).append("\n");
            prompt.append("- 卖点：").append(product.get("卖点")).append("\n");
            prompt.append("- 价格：¥").append(product.get("价格")).append("\n\n");
        }

        prompt.append("请从以下几个方面进行分析：\n");
        prompt.append("1. 基本信息对比\n");
        prompt.append("2. 价格分析（包括价格区间、最高价、最低价、价差等）\n");
        prompt.append("3. 性价比分析（根据价格和卖点分析每个商品的定位和适合人群）\n");
        prompt.append("4. 购买建议（针对不同需求给出推荐）\n\n");
        prompt.append("请用Markdown格式输出，使用标题、列表等格式使内容清晰易读。\n\n\n\n");

        return prompt.toString();
    }

    /**
     * 本地生成对话回复（当AI API不可用时使用）
     */
    private String generateLocalResponse(String query) {
        // 简单的本地回复逻辑
        if (query.contains("推荐") || query.contains("热门")) {
            return "根据商城数据，以下是热门手办商品推荐：\n\n" +
                   "1. 初音未来手办 - ¥299.00\n" +
                   "   特点：高质量PVC材质，细节精致\n\n" +
                   "2. 原神手办 - ¥199.00\n" +
                   "   特点：热门游戏角色，精美造型\n\n" +
                   "3. 海贼王手办 - ¥259.00\n" +
                   "   特点：经典动漫角色，收藏价值高\n\n" +
                   "具体选择建议根据您的喜好和预算来决定。";
        } else if (query.contains("比价") || query.contains("对比")) {
            return "我可以帮您对比手办商品价格。请告诉我您想对比的手办名称或类型，我会为您提供详细的价格分析和购买建议。";
        } else if (query.contains("手办") || query.contains("动漫")) {
            return "商城中有丰富的手办类商品：\n\n" +
                   "1. 初音未来手办 - ¥299.00\n" +
                   "   特点：高质量PVC材质，细节精致\n\n" +
                   "2. 原神手办 - ¥199.00\n" +
                   "   特点：热门游戏角色，精美造型\n\n" +
                   "如果您需要更详细的对比分析，请告诉我具体型号，我可以为您提供专业的购买建议。";
        } else if (query.contains("订单")) {
            // 检查用户是否已登录
            String userIdStr = TokenUtils.getCurrUser();
            if (userIdStr == null) {
                return "请先登录后再查询订单信息。";
            }
            return "我可以帮您查询订单信息。请告诉我您想查询的订单号或者说明您想查询的订单状态（如：已支付、未支付、已发货、已完成、退款中等）。";
        } else if (query.contains("购物车")) {
            // 检查用户是否已登录
            String userIdStr = TokenUtils.getCurrUser();
            if (userIdStr == null) {
                return "请先登录后再查询购物车信息。";
            }
            return "我可以帮您查询购物车内容。请问您想了解购物车中的哪些商品信息？";
        } else if (query.contains("发货") || query.contains("物流")) {
            // 检查用户是否已登录
            String userIdStr = TokenUtils.getCurrUser();
            if (userIdStr == null) {
                return "请先登录后再查询发货信息。";
            }
            return "我可以帮您查询发货信息和物流状态。请提供您的订单号，我可以为您查询具体的发货时间和物流信息。";
        } else if (query.contains("退款")) {
            // 检查用户是否已登录
            String userIdStr = TokenUtils.getCurrUser();
            if (userIdStr == null) {
                return "请先登录后再查询退款信息。";
            }
            return "我可以帮您查询退款进度。请提供您的订单号，我可以为您查询具体的退款原因和处理进度。";
        } else {
            // 检查用户是否已登录，以决定显示哪些功能
            String userIdStr = TokenUtils.getCurrUser();
            if (userIdStr == null) {
                return "您好！我是智能商城助手，我可以帮您：\n" +
                       "1. 推荐热门手办商品\n" +
                       "2. 对比手办商品价格\n\n" +
                       "请先登录以使用更多功能。";
            } else {
                return "您好！我是智能商城助手，我可以帮您：\n" +
                       "1. 推荐热门手办商品\n" +
                       "2. 对比手办商品价格\n" +
                       "3. 查询订单信息\n" +
                       "4. 查询购物车内容\n" +
                       "5. 查询发货和物流信息\n" +
                       "6. 查询退款信息\n\n" +
                       "请告诉我您需要什么帮助？";
            }
        }
    }

    /**
     * 本地生成分析结果（当AI API不可用时使用）
     */
    private String generateLocalAnalysis(List<Map<String, Object>> products) {
        StringBuilder analysis = new StringBuilder();
        
        analysis.append("### 📊 商品对比分析报告\n\n");
        
        // 基本信息对比
        analysis.append("#### 一、基本信息对比\n\n");
        for (int i = 0; i < products.size(); i++) {
            Map<String, Object> product = products.get(i);
            analysis.append("**商品").append(i + 1).append("：").append(product.get("商品名称")).append("**\n");
            analysis.append("- 💰 价格：¥").append(product.get("价格")).append("\n");
            analysis.append("- 📝 卖点：").append(product.get("卖点")).append("\n\n");
        }

        // 价格分析
        analysis.append("#### 二、价格分析\n\n");
        analysis.append(analyzePrices(products)).append("\n\n");

        // 性价比分析
        analysis.append("#### 三、性价比分析\n\n");
        analysis.append(analyzeCostPerformance(products)).append("\n\n");

        // 购买建议
        analysis.append("#### 四、购买建议\n\n");
        analysis.append(generateBuyingSuggestion(products)).append("\n\n");

        analysis.append("---\n");
        analysis.append("*本分析由系统智能生成，仅供参考。建议结合实际需求和用户评价综合考虑。*\n");

        return analysis.toString();
    }

    /**
     * 价格分析
     */
    private String analyzePrices(List<Map<String, Object>> products) {
        List<Double> prices = new ArrayList<>();
        for (Map<String, Object> product : products) {
            Object priceObj = product.get("价格");
            double price = priceObj instanceof Number ? 
                ((Number) priceObj).doubleValue() : 
                Double.parseDouble(priceObj.toString());
            prices.add(price);
        }

        double maxPrice = prices.stream().mapToDouble(Double::doubleValue).max().orElse(0);
        double minPrice = prices.stream().mapToDouble(Double::doubleValue).min().orElse(0);
        double avgPrice = prices.stream().mapToDouble(Double::doubleValue).average().orElse(0);
        
        int maxIndex = prices.indexOf(maxPrice);
        int minIndex = prices.indexOf(minPrice);

        StringBuilder result = new StringBuilder();
        result.append("- 📈 价格区间：¥").append(String.format("%.2f", minPrice))
              .append(" - ¥").append(String.format("%.2f", maxPrice)).append("\n");
        result.append("- 📊 平均价格：¥").append(String.format("%.2f", avgPrice)).append("\n");
        result.append("- 💎 最高价：商品").append(maxIndex + 1).append("（¥")
              .append(String.format("%.2f", maxPrice)).append("）\n");
        result.append("- 💰 最低价：商品").append(minIndex + 1).append("（¥")
              .append(String.format("%.2f", minPrice)).append("）\n");
        result.append("- 📉 价差：¥").append(String.format("%.2f", maxPrice - minPrice));

        return result.toString();
    }

    /**
     * 性价比分析
     */
    private String analyzeCostPerformance(List<Map<String, Object>> products) {
        StringBuilder result = new StringBuilder();
        
        for (int i = 0; i < products.size(); i++) {
            Map<String, Object> product = products.get(i);
            Object priceObj = product.get("价格");
            double price = priceObj instanceof Number ? 
                ((Number) priceObj).doubleValue() : 
                Double.parseDouble(priceObj.toString());
            
            String priceLevel = getPriceLevel(price);
            String suitableGroup = getSuitableGroup(price);
            String sellPoint = product.get("卖点").toString();
            
            result.append("**商品").append(i + 1).append("分析：**\n");
            result.append("- 定位：").append(priceLevel).append("产品\n");
            result.append("- 特点：").append(sellPoint.length() > 50 ? 
                sellPoint.substring(0, 50) + "..." : sellPoint).append("\n");
            result.append("- 适合人群：").append(suitableGroup).append("\n\n");
        }

        return result.toString();
    }

    /**
     * 生成购买建议
     */
    private String generateBuyingSuggestion(List<Map<String, Object>> products) {
        List<Double> prices = new ArrayList<>();
        for (Map<String, Object> product : products) {
            Object priceObj = product.get("价格");
            double price = priceObj instanceof Number ? 
                ((Number) priceObj).doubleValue() : 
                Double.parseDouble(priceObj.toString());
            prices.add(price);
        }

        double minPrice = prices.stream().mapToDouble(Double::doubleValue).min().orElse(0);
        int minIndex = prices.indexOf(minPrice);
        double maxPrice = prices.stream().mapToDouble(Double::doubleValue).max().orElse(0);
        int maxIndex = prices.indexOf(maxPrice);

        StringBuilder result = new StringBuilder();
        result.append("1. **预算优先选择：** 如果注重性价比，推荐选择商品").append(minIndex + 1)
              .append("（¥").append(String.format("%.2f", minPrice))
              .append("），价格最实惠。\n\n");
        
        result.append("2. **品质优先选择：** 如果追求品质和体验，可以考虑商品").append(maxIndex + 1)
              .append("（¥").append(String.format("%.2f", maxPrice))
              .append("），通常高价位产品在品质和功能上更有优势。\n\n");
        
        result.append("3. **综合建议：** 建议根据个人实际需求和预算综合考虑。")
              .append("查看商品详细信息、用户评价，选择最适合自己的产品。\n\n");
        
        result.append("4. **购买时机：** 建议关注商家活动和优惠券，可以获得更优惠的价格。\n\n");

        return result.toString();
    }

    private String getPriceLevel(double price) {
        if (price > 300) return "高端";
        if (price > 200) return "中高端";
        if (price > 100) return "中端";
        return "入门";
    }

    private String getSuitableGroup(double price) {
        if (price > 300) return "追求高品质、预算充足的收藏者";
        if (price > 200) return "注重性价比、有一定预算的手办爱好者";
        if (price > 100) return "预算适中、追求实用的手办收藏者";
        return "预算有限、追求经济实惠的手办入门者";
    }
}